#include "bmp_api.h"

#define BMP_16_16_SIZE (126)
/*********************************************************************
 *  名称： get_bmps_start_position_index
 *  功能： 根据digimon_id 获取对应bmp资源在falsh中的起始位置的下标
 *  参数： int id 
 *  返回值：uint16_t 返回对应id在flash中的起始位置，这里只返回下标 （下标 × sizeof(bmp) = postion）
 ********************************************************************/
static uint16_t get_bmps_start_position_index(int id)
{
    uint16_t index = 0;
    uint16_t _id = 0;
    for (_id = 0; _id < id; _id++)
    {
        index += digimon_libs[_id].bmp_num;
    }
    return index;
}

static void get_bmp_form_flash(uint16_t id, uint8_t index, char *tempSaveData)
{
    uint16_t all_index = get_bmps_start_position_index(id) + index;

    spi_flash_read(0x200000 + (all_index * BMP_16_16_SIZE), (void *)tempSaveData, BMP_16_16_SIZE);
}

/*********************************************************************
 *  名称： bmp_data_to_array
 *  功能： 将flash中读取的bmp数据填充到16×2的二级数组中
 *  参数： char *bmp_data flash读取的bmp数据
 *  参数： char (*array)[2] 二级数组指针
 *  返回值：void
 ********************************************************************/
static void bmp_data_to_array(char *bmp_data, char (*array)[2])
{
    char *pos;
    uint8_t w = 16;
    uint8_t h = 16;
    uint8_t len;
    len = ((31 + w) / 32) * 4;
    uint8_t i, j;

    for (i = 0; i < h; i++)
    {
        pos = bmp_data + BMP_16_16_SIZE - (len * (i + 1));

        for (j = 0; j < w; j += 8)
        {
            array[i][j / 8] = (unsigned char)~(pos[j / 8]);
        }
    }
}

/*********************************************************************
 *  名称： bmp_f16_t48
 *  功能： 将16*16的bmp放大到48×48
 *  参数： char *bmp_data flash读取的bmp数据
 *  参数： char (*array)[16] 二级数组指针
 *  返回值：void
 ********************************************************************/
void bmp_f16_t48(char (*in_array)[2], char (*out_array)[48])
{
    int i = 0, j = 0, k = 0;
    char arr16_16[16][16] = {0};
    /* 1.先把16×2 展开成2进制的16×16 */
    for (i = 0; i < 16; i++)
    {
        for (j = 0; j < 2; j++)
        {
            for (k = 0; k < 8; k++)
            {
                arr16_16[j * 8 + k][i] = 0x01 & (in_array[i][j] >> (7 - k));
            }
        }
    }

    for (i = 0; i < 16; i++)
    {
        for (j = 0; j < 16; j++)
        {
            if (arr16_16[j][i] == 1)
            {
                out_array[j * 3][i * 3] = 1;
                out_array[j * 3][i * 3 + 1] = 1;
                out_array[j * 3][i * 3 + 2] = 1;
                out_array[j * 3 + 1][i * 3] = 1;
                out_array[j * 3 + 1][i * 3 + 1] = 1;
                out_array[j * 3 + 1][i * 3 + 2] = 1;
                out_array[j * 3 + 2][i * 3] = 1;
                out_array[j * 3 + 2][i * 3 + 1] = 1;
                out_array[j * 3 + 2][i * 3 + 2] = 1;
            }
        }
    }
}

/*********************************************************************
 *  名称： bmp_f48_t6
 *  功能： 将48*48的二进制转成16进制
 *  参数： char *bmp_data flash读取的bmp数据
 *  参数： char (*array)[16] 二级数组指针
 *  返回值：void
 ********************************************************************/
void bmp_f48_t6(char (*in_array)[48], unsigned char (*arr48_6)[6])
{
    int nuu = 0;
    int i = 0, j = 0;
    for (i = 0; i < 48; i++)
    {
        for (j = 0; j < 48; j++)
        {
            nuu += in_array[i][j] * pow(2, (7 - j % 8));
            if (((j + 1) % 8 == 0) && j > 0)
            {
                arr48_6[i][j / 8] = nuu;
                nuu = 0;
            }
        }
    }
}

static int init_one_bmp(uint16_t id, uint8_t index, unsigned char (*digimon_bmps)[48][6])
{
    char tempSaveData[BMP_16_16_SIZE] = {0};
    char arr16_2[16][2] = {0};
    char arr48_48[48][48] = {0};

    //1. get bmp form flash
    get_bmp_form_flash(id, index, tempSaveData);

    //2. bmp data to array
    bmp_data_to_array(tempSaveData, arr16_2);

    //3. 16_16 to 48_48
    bmp_f16_t48(arr16_2, arr48_48);

    //4. arr48_48 to arr 48_6
    bmp_f48_t6(arr48_48, digimon_bmps[index]);

    return 0;
}

int init_digimon_bmps(uint16_t id, unsigned char *bmps[48][6])
{

    int index = 0;
    for (index = 0; index < digimon_libs[id].bmp_num; index++)
    {
        init_one_bmp(id, index, bmps);
    }
    return 0;
}

int init_digimon_bmps_only_one(uint16_t id, unsigned char *bmps[48][6])
{
    init_one_bmp(id, 0, bmps);
    return 0;
}